Changeset 4:0a29ce1ae854

Show
Ignore:
Timestamp:
05/13/09 15:01:55 (4 years ago)
Author:
SokoL_SD
branch:
default
convert_revision:
svn:1c76f9a9-97a6-433d-956c-bb6a2077f4c7/trunk@8
Message:

CMake build script.
Small fixes in examples.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • CMakeLists.txt

    r1 r4  
     1cmake_minimum_required(VERSION 2.6) 
    12PROJECT(qtd CXX C) 
    2 cmake_minimum_required(VERSION 2.6) 
    33FIND_PACKAGE(Qt4 REQUIRED) 
    4 # Using Tango 
    5  
    6 #set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules/cmaked) 
    7 #set(CMAKE_D_USE_TANGO True) 
    84 
    95include_directories(${QT_INCLUDES} include) 
    106 
    11 IF(CMAKE_HOST_WIN32) 
    12     INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cpp/qt_core/local.cmake) 
    13     INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cpp/qt_gui/local.cmake) 
    14     INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cpp/qt_opengl/local.cmake) 
    15 #    INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cpp/qt_qtd/local.cmake) 
    16     ADD_LIBRARY(qtd_cpp SHARED ${QT_QTD_SRCS} ${QT_CORE_SRCS} ${QT_GUI_SRCS}) 
    17     TARGET_LINK_LIBRARIES( qtd_cpp ${QT_LIBRARIES} ) 
    18 ELSE(CMAKE_HOST_WIN32) 
    19     ADD_SUBDIRECTORY(cpp/qt_core bin) 
    20     ADD_SUBDIRECTORY(cpp/qt_gui bin) 
    21     ADD_SUBDIRECTORY(cpp/qt_opengl bin) 
    22     ADD_SUBDIRECTORY(cpp/qt_qtd bin) 
    23 ENDIF(CMAKE_HOST_WIN32) 
    24  
    25 #ADD_SUBDIRECTORY(qt bin) 
    26  
     7option(BUILD_QT_OPENGL "Build QtOpenGL" "ON") 
     8option(BUILD_EXAMPLES "Build examples" "ON") 
     9 
     10set(PACKAGES Core Gui) 
     11if(BUILD_QT_OPENGL) 
     12    set(PACKAGES ${PACKAGES} OpenGL) 
     13endif(BUILD_QT_OPENGL) 
     14 
     15set(packages_big ${PACKAGES}) 
     16set(packages) 
     17foreach(package ${packages_big}) 
     18    string(TOLOWER ${package} package) 
     19    set(packages ${packages} ${package}) 
     20endforeach(package ${packages_big}) 
     21 
     22#set(CMAKE_LIBRARY_OUTPUT_DIRECTORY CMakeFiles) 
     23 
     24find_program(DC dmd ldc) 
     25## Parsing D compiler version. 
     26if (DC)    
     27    exec_program(${DC} ARGS "" OUTPUT_VARIABLE d_output)    
     28    string(REGEX MATCH "Digital Mars D Compiler v[0-9]\\.[0-9]+" dmd_version "${d_output}") 
     29    if (dmd_version) 
     30    set(D_IS_MARS true) 
     31    set(D_COMPILER_NAME "Digital Mars D Compiler") 
     32    string(REGEX REPLACE "Digital Mars D Compiler v([0-9])\\.[0-9]+" "\\1" D_VERSION "${dmd_version}") 
     33    string(REGEX REPLACE "Digital Mars D Compiler v[0-9]\\.([0-9]+)" "\\1" D_FRONTEND "${dmd_version}")     
     34    else (dmd_version) 
     35    string(REGEX MATCH "LLVM-based D Compiler" is_ldc "${d_output}")    
     36    if (is_ldc) 
     37        exec_program(${DC} ARGS "--version" OUTPUT_VARIABLE d_output) 
     38        string(REGEX MATCH "based on DMD v[0-9]\\.[0-9]+ and llvm [0-9]\\.[0-9]+" ldc_version "${d_output}") 
     39        set(D_IS_LLVM true) 
     40        if(ldc_version) 
     41        set(D_IS_LLVM true) 
     42        set(D_COMPILER_NAME "LLVM-based D Compiler") 
     43        string(REGEX REPLACE "based on DMD v([0-9])\\.[0-9]+ and llvm [0-9]\\.[0-9]+" "\\1" D_VERSION "${ldc_version}") 
     44        string(REGEX REPLACE "based on DMD v[0-9]\\.([0-9]+) and llvm [0-9]\\.[0-9]+" "\\1" D_FRONTEND "${ldc_version}")         
     45        else(ldc_version) 
     46        message(FATAL_ERROR "LDC compiler was found, but the version can not be processed") 
     47        endif(ldc_version) 
     48    else (is_ldc)  
     49        message(FATAL_ERROR "D compliler not founded") 
     50    endif(is_ldc) 
     51    endif(dmd_version)    
     52    message(STATUS "D compiler founded -- ${D_COMPILER_NAME} v${D_VERSION}.${D_FRONTEND}") 
     53else (DC) 
     54    message(FATAL_ERROR "D compliler not founded") 
     55endif (DC) 
     56 
     57# Check D compiler version 
     58if(D_VERSION EQUAL "1") 
     59    if (D_FRONTEND LESS "041") 
     60    message(STATUS "Minimum required version of D compiler is 1.041 (or compiler based on this version)") 
     61    endif(D_FRONTEND LESS "041") 
     62    set(D_TARGET d1-tango) 
     63elseif(D_VERSION EQUAL "2") 
     64    set(D_TARGET ) ## TODO: hm... I don`t known this parameter for D2 ^( 
     65endif(D_VERSION EQUAL "1") 
     66 
     67if(D_IS_MARS) 
     68    set(SEPARETLY_D_OBJECTS true) 
     69elseif(D_IS_LLVM) 
     70    set(SEPARETLY_D_OBJECTS true) 
     71endif(D_IS_MARS) 
     72 
     73# Debug and release flags. 
     74if (${CMAKE_BUILD_TYPE} MATCHES [dD][eE][bB][uU][gG]) 
     75   #set(CMAKE_BUILD_TYPE Debug) 
     76   #set( SUFFIXLIB "${SUFFIXLIB}-debug" ) 
     77   #set( SUFFIXBIN "${SUFFIXBIN}-debug" ) 
     78   add_definitions(-DDEBUG) 
     79   set(D_FLAGS -g -gc -debug) 
     80else (${CMAKE_BUILD_TYPE} MATCHES [dD][eE][bB][uU][gG]) 
     81   #set(CMAKE_BUILD_TYPE Release) 
     82    add_definitions(-UNO_DEBUG) 
     83    set(D_FLAGS -O -release -inline) 
     84    if(${CMAKE_SYSTEM_NAME} STREQUAL Windows) 
     85      set(D_FLAGS ${D_FLAGS} -L/subsystem:windows) 
     86    endif(${CMAKE_SYSTEM_NAME} STREQUAL Windows)    
     87endif (${CMAKE_BUILD_TYPE} MATCHES [dD][eE][bB][uU][gG])   
     88set(D_FLAGS ${D_FLAGS} -I${CMAKE_BINARY_DIR} -I${CMAKE_SOURCE_DIR}) 
     89 
     90MACRO(MAKE_WINDOWS_PATH pathname) 
     91    if(${CMAKE_SYSTEM_NAME} STREQUAL Windows) 
     92    # An extra \\ escape is necessary to get a \ through CMake's processing. 
     93    STRING(REPLACE "/" "\\" ${pathname} "${${pathname}}") 
     94    # Enclose with UNESCAPED quotes.  This means we need to escape our 
     95    # quotes once here, i.e. with \" 
     96    SET(${pathname} \"${${pathname}}\") 
     97    endif(${CMAKE_SYSTEM_NAME} STREQUAL Windows)  
     98ENDMACRO(MAKE_WINDOWS_PATH) 
     99 
     100if(${CMAKE_SYSTEM_NAME} STREQUAL Windows) 
     101    set(implib implib) 
     102    find_program(IMPLIB ${implib}) 
     103    if (NOT IMPLIB) 
     104    message(FATAL_ERROR "implib not found. You can donwload it from http://ftp.digitalmars.com/bup.zip") 
     105    endif (NOT IMPLIB) 
     106    set(D_OBJECT_SUFFIX .obj) 
     107    if(D_IS_MARS) 
     108      set(D_LIB_SUFFIX .lib) 
     109      set(D_LIB_PREFIX ) 
     110    elseif(D_IS_LDC) 
     111      set(D_LIB_SUFFIX .a) 
     112      set(D_LIB_PREFIX lib) 
     113    endif(D_IS_MARS) 
     114    set(GEN_OPT ${GEN_OPT} --cpp_shared) 
     115    add_definitions(-DCPP_SHARED) 
     116elseif(${CMAKE_SYSTEM_NAME} STREQUAL Linux)  
     117    set(D_LIB_SUFFIX .a) 
     118    set(D_LIB_PREFIX lib) 
     119    set(D_OBJECT_SUFFIX .o) 
     120endif(${CMAKE_SYSTEM_NAME} STREQUAL Windows)  
     121 
     122set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} ./) 
     123set(GEN_OPT ${GEN_OPT} --d-target=${D_TARGET}) 
     124 
     125add_subdirectory(generator) 
     126 
     127macro(OBJ_PATH path) 
     128    unset(test) 
     129    string(REGEX MATCH "${CMAKE_CURRENT_BINARY_DIR}/.*" test "${${path}}")     
     130    if(NOT ${test} EQUAL "") 
     131    string(LENGTH "${CMAKE_CURRENT_BINARY_DIR}" first) 
     132    string(LENGTH "${${path}}" last) 
     133    math(EXPR first "${first} + 1") 
     134    math(EXPR len "${last} - ${first}")  
     135    string(SUBSTRING "${${path}}" ${first} ${len} ${path}) 
     136    else(NOT ${test} EQUAL "") 
     137    string(REGEX MATCH "${CMAKE_CURRENT_SOURCE_DIR}/.*" test "${${path}}")     
     138    if(NOT ${test} EQUAL "") 
     139        string(LENGTH "${CMAKE_CURRENT_SOURCE_DIR}" first) 
     140        string(LENGTH "${${path}}" last) 
     141        math(EXPR first "${first} + 1") 
     142        math(EXPR len "${last} - ${first}")  
     143        string(SUBSTRING "${${path}}" ${first} ${len} ${path}) 
     144    endif(NOT ${test} EQUAL "") 
     145    endif(NOT ${test} EQUAL "") 
     146endmacro(OBJ_PATH) 
     147 
     148macro(compile_d_files target objects_list) 
     149    unset(${objects_list}) 
     150    set(tmp_dir ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${target}.dir) 
     151    file(MAKE_DIRECTORY ${tmp_dir}) 
     152    if(${SEPARETLY_D_OBJECTS}) 
     153    foreach (d_source ${ARGN}) 
     154        OBJ_PATH(d_source) 
     155        set(d_obj ${tmp_dir}/${d_source}${D_OBJECT_SUFFIX}) 
     156        set(${objects_list} ${${objects_list} ${d_obj}) 
     157        get_filename_component(path ${d_obj} PATH)       
     158        file(MAKE_DIRECTORY ${path}) 
     159        set(d_obj_out ${d_obj}) 
     160        OBJ_PATH(d_obj_out) 
     161        add_custom_command(OUTPUT "${d_obj}" 
     162            COMMAND "${DC}" 
     163            ARGS ${D_FLAGS} -c ${d_source} -of${d_obj} 
     164            COMMENT "Building ${d_obj_out}" 
     165            DEPENDS ${d_source} 
     166            ) 
     167    endforeach(d_source) 
     168    else(${SEPARETLY_D_OBJECTS}) 
     169    set(${objects_list} ${tmp_dir}/${target}${D_OBJECT_SUFFIX}) 
     170    set(d_obj_out ${${objects_list}}) 
     171    OBJ_PATH(d_obj_out) 
     172    set(parameters_list_file ${tmp_dir}/parameters) 
     173    SET (parameters ${D_FLAGS} -c ${ARGN} -of${${objects_list}}) 
     174    FILE (REMOVE ${parameters_list_file}) 
     175    FOREACH(arg ${parameters}) 
     176        FILE (APPEND ${parameters_list_file} "${arg}\n") 
     177    ENDFOREACH(arg) 
     178    add_custom_command(OUTPUT "${${objects_list}}" 
     179            COMMAND "${DC}" 
     180            ARGS @${parameters_list_file} 
     181            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} 
     182            DEPENDS ${ARGN} 
     183            COMMENT "" 
     184            ) 
     185    endif(${SEPARETLY_D_OBJECTS}) 
     186endmacro(compile_d_files objects_list) 
     187 
     188file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/lib) 
     189add_custom_target(allpackages ALL) 
     190 
     191link_directories(${CMAKE_BINARY_DIR}/CMakeFiles) 
     192 
     193foreach(package ${packages})     
     194    unset(d_objs) 
     195    unset(cpp_objs) 
     196    unset(d_sources) 
     197    unset(cpp_sources) 
     198    unset(lib_name) 
     199    unset(link_cpp) 
     200    unset(link_d) 
     201    unset(cpp_files) 
     202    unset(d_files) 
     203    unset(classes) 
     204    unset(d_generated_files) 
     205    
     206    include (${CMAKE_SOURCE_DIR}/build/${package}.txt)     
     207 
     208    set(${package}_link_example "${link_example}") 
     209    set(${link_example} "") 
     210 
     211    set(CUR_TMP_PATH CMakeFiles/${package}.dir)   
     212     
     213    set(classes ArrayOps ${classes}) 
     214    foreach(class ${classes}) 
     215    set(d_sources ${d_sources} ${CMAKE_BINARY_DIR}/qt/${package}/${class}.d)     
     216    set(cpp_sources ${cpp_sources} ${CMAKE_BINARY_DIR}/cpp/qt_${package}/${class}_shell.cpp)     
     217    endforeach(class) 
     218    add_sources_for_generating(${cpp_sources}) 
     219     
     220    foreach(d_source ${d_files}) 
     221    set(d_sources ${d_sources} ${CMAKE_SOURCE_DIR}/qt/${d_source}.d) 
     222    endforeach(d_source) 
     223    foreach(d_source ${d_generated_files}) 
     224    set(d_sources ${d_sources} ${CMAKE_BINARY_DIR}/qt/${d_source}.d) 
     225    endforeach(d_source) 
     226    foreach (cpp_source ${cpp_files}) 
     227    set(cpp_sources ${cpp_sources} ${CMAKE_SOURCE_DIR}/cpp/${cpp_source}.cpp) 
     228    endforeach(cpp_source) 
     229     
     230    compile_d_files(${package}_dobjs objects  ${d_sources}) 
     231    set(d_objs ${d_objs} ${objects})  
     232     
     233    set(lib_name ${D_LIB_PREFIX}qtd${package}${D_LIB_SUFFIX}) 
     234     
     235    add_library(cpp_${package} SHARED ${cpp_sources}) 
     236    add_dependencies(cpp_${package} dgen) 
     237    if(${CMAKE_SYSTEM_NAME} STREQUAL Windows) 
     238    set_property(TARGET cpp_${package} PROPERTY RUNTIME_OUTPUT_DIRECTORY lib) 
     239    set_property(TARGET cpp_${package} PROPERTY ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles)     
     240    ADD_CUSTOM_COMMAND( 
     241          TARGET cpp_${package} 
     242          POST_BUILD 
     243          COMMAND ${CMAKE_COMMAND} -E remove 
     244              ${CMAKE_BINARY_DIR}/CMakeFiles/${CMAKE_IMPORT_LIBRARY_PREFIX}cpp${package}${CMAKE_IMPORT_LIBRARY_SUFFIX} 
     245          COMMAND ${CMAKE_COMMAND} -E copy  
     246              ${CMAKE_BINARY_DIR}/CMakeFiles/${CMAKE_IMPORT_LIBRARY_PREFIX}cpp_${package}.dll${CMAKE_IMPORT_LIBRARY_SUFFIX} 
     247              ${CMAKE_BINARY_DIR}/CMakeFiles/${CMAKE_IMPORT_LIBRARY_PREFIX}cpp${package}${CMAKE_IMPORT_LIBRARY_SUFFIX} 
     248    ) 
     249 
     250    target_link_libraries(cpp_${package} ${link_cpp} ) 
     251    set(cpp_lib ${CMAKE_BINARY_DIR}/lib/libcpp_${package}.dll) 
     252    set(cpp_lib_native ${cpp_lib}) 
     253    MAKE_WINDOWS_PATH(cpp_lib_native) 
     254    set(d_implib ${CMAKE_BINARY_DIR}/CMakeFiles/${package}.dir/cpp_${package}.lib) 
     255    set(d_implib_native ${d_implib}) 
     256    MAKE_WINDOWS_PATH(d_implib_native)   
     257    set(cpp_${package}_implib cpp${package}) 
     258    add_custom_command( 
     259            OUTPUT "${d_implib}" 
     260            COMMAND "${IMPLIB}" 
     261            ARGS /system /PAGESIZE:32 ${d_implib_native} ${cpp_lib_native} 
     262            DEPENDS  "cpp_${package}" 
     263            COMMENT "Creating implib ${lib_name}" 
     264            ) 
     265    add_custom_command( 
     266            OUTPUT "${lib_name}" 
     267            COMMAND "${DC}" 
     268            ARGS -lib ${d_objs} ${d_implib} -oflib/${lib_name} 
     269            DEPENDS ${d_objs} ${d_implib} 
     270            COMMENT "Linking ${lib_name}" 
     271            ) 
     272    else(${CMAKE_SYSTEM_NAME} STREQUAL Linux)    
     273    set_property(TARGET cpp_${package} PROPERTY LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/CMakeFiles) 
     274    foreach(cpp_source ${cpp_sources}) 
     275        set(cpp_source ${cpp_source}) 
     276        OBJ_PATH(cpp_source) 
     277        set(cpp_objs ${cpp_objs} CMakeFiles/cpp_${package}.dir/${cpp_source}.o) 
     278    endforeach(cpp_source) 
     279     
     280    add_custom_command( 
     281            OUTPUT "${lib_name}" 
     282            COMMAND "${CMAKE_AR}" 
     283            ARGS rcs lib/${lib_name} ${d_objs} ${cpp_objs} 
     284            DEPENDS ${d_objs} cpp_${package} 
     285            COMMENT "Linking ${lib_name}" 
     286            ) 
     287    endif(${CMAKE_SYSTEM_NAME} STREQUAL Windows)  
     288    add_custom_target(${package} DEPENDS ${lib_name}) 
     289    foreach(depend ${depends}) 
     290    add_dependencies(cpp_${package} cpp_${depend}) 
     291    add_dependencies(${package} ${depend}) 
     292    endforeach(depend ${depends}) 
     293    add_dependencies(allpackages ${package}) 
     294    set(depends ${depends} ${package}) 
     295endforeach(package) 
     296 
     297foreach(package_big ${packages_big}) 
     298    string(TOLOWER ${package_big} package)   
     299    if(${CMAKE_SYSTEM_NAME} STREQUAL Windows AND D_IS_MARS) 
     300    set(libs_path ${CMAKE_BINARY_DIR}/lib/qtd${package}.lib) 
     301    MAKE_WINDOWS_PATH(libs_path) 
     302    set(${package}_lib_param -L+${libs_path}) 
     303    foreach(link ${${package}_link_example}) 
     304        set(link ${CMAKE_SOURCE_DIR}/lib/${link}.lib) 
     305        MAKE_WINDOWS_PATH(link) 
     306        set(link -L+${link}) 
     307        set(${package}_lib_param ${${package}_lib_param} ${link}) 
     308    endforeach(link ${link_example}) 
     309    else (${CMAKE_SYSTEM_NAME} STREQUAL Windows AND D_IS_MARS) 
     310    set(${package}_lib_param -L-lqtd${package} -L-lQt${package_big}) 
     311    foreach(link ${link_example}) 
     312        set(${package}_lib_param ${${package}_lib_param} ${link}) 
     313    endforeach(link ${link_example}) 
     314    endif(${CMAKE_SYSTEM_NAME} STREQUAL Windows AND D_IS_MARS) 
     315endforeach(package_big ${packages_big}) 
     316 
     317macro(build_example name) 
     318    unset(is_sources) 
     319    unset(is_libs) 
     320    set(qtd_libs ${core_lib_param} ${gui_lib_param}) 
     321    foreach(param ${ARGN}) 
     322    if(is_libs)      
     323        string(REGEX REPLACE "Qt([A-Za-z0-9])" "\\1" param_package "${param}")   
     324        if(${param_package} STREQUAL ${param}) 
     325        unset(is_libs) 
     326        set(is_sources 1) 
     327        else(${param_package} STREQUAL ${param}) 
     328        unset(is_founded) 
     329        foreach(package_big ${packages_big}) 
     330            string(TOLOWER ${package_big} package)           
     331            if(${param_package} STREQUAL ${package_big}) 
     332            set(qtd_libs ${qtd_libs} ${${package}_lib_param}) 
     333            set(is_founded 1) 
     334            break(package_big ${packages_big}) 
     335            endif(${param_package} STREQUAL ${package_big}) 
     336        endforeach(package_big ${packages_big}) 
     337        if(NOT is_founded) 
     338              message(STATUS "Module ${param_package} not founded for example ${name}") 
     339              return(build_example name) 
     340        endif(NOT is_founded) 
     341        endif(${param_package} STREQUAL ${param}) 
     342    endif(is_libs) 
     343    if(NOT is_libs) 
     344      if(NOT is_sources)           
     345          if(${param} STREQUAL PACKAGES) 
     346          set(is_libs 1) 
     347          set(qtd_libs) 
     348          else(${param} STREQUAL PACKAGES) 
     349          set(is_sources 1) 
     350          endif(${param} STREQUAL PACKAGES)        
     351      endif(NOT is_sources)  
     352      if(is_sources) 
     353          set(sources ${sources} ${param}) 
     354      endif(is_sources)   
     355    endif(NOT is_libs) 
     356    endforeach(param ${ARGN}) 
     357    if(${CMAKE_SYSTEM_NAME} STREQUAL Windows AND D_IS_MARS) 
     358    set(libs_path ) 
     359    else(${CMAKE_SYSTEM_NAME} STREQUAL Windows AND D_IS_MARS) 
     360    set(libs_path -L-L${CMAKE_BINARY_DIR}/lib) 
     361    endif(${CMAKE_SYSTEM_NAME} STREQUAL Windows AND D_IS_MARS) 
     362    compile_d_files(${name}_dobjs objects ${sources} ) 
     363    set(output ${CMAKE_CURRENT_BINARY_DIR}/${name}${CMAKE_EXECUTABLE_SUFFIX}) 
     364    set(output_native ${output}) 
     365    make_windows_path(output_native) 
     366    add_custom_command(OUTPUT "${output}" 
     367            COMMAND "${DC}" 
     368            ARGS ${D_FLAGS} ${libs_path} ${qtd_libs} ${objects}  
     369            -of${output_native} 
     370            DEPENDS ${objects} 
     371            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} 
     372            COMMENT "Building example ${name}" 
     373            ) 
     374    add_custom_target(example_${name} ALL DEPENDS "${output}") 
     375    add_dependencies(example_${name} allpackages) 
     376endmacro(build_example sources) 
     377 
     378if(BUILD_QT_OPENGL) 
     379    add_subdirectory(demos) 
     380    add_subdirectory(examples) 
     381endif(BUILD_QT_OPENGL) 
  • examples/opengl/hellogl/glwidget.d

    r1 r4  
    5151{ 
    5252//    Q_OBJECT 
    53  
     53     
    5454    public: 
    5555        this(QWidget parent = null) 
     
    6060            yRot = 0; 
    6161            zRot = 0; 
    62  
     62             
    6363            trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0); 
    6464            trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0); 
    65         } 
    66  
     65             
     66        } 
     67         
    6768        ~this() 
    6869        { 
    6970            makeCurrent(); 
    7071            glDeleteLists(object, 1); 
    71         } 
    72  
     72        }         
     73         
    7374        QSize minimumSizeHint() 
    7475        { 
     
    9293            } 
    9394        } 
    94  
     95         
    9596        void setYRotation(int angle) 
    9697        { 
     
    102103            } 
    103104        } 
    104  
     105         
    105106        void setZRotation(int angle) 
    106107        { 
     
    112113            } 
    113114        } 
    114  
     115         
    115116        mixin Signal!("xRotationChanged", int); 
    116117        mixin Signal!("yRotationChanged", int); 
    117118        mixin Signal!("zRotationChanged", int); 
    118  
     119         
    119120 
    120121    protected: 
     
    143144            int side = qMin(width, height); 
    144145            glViewport((width - side) / 2, (height - side) / 2, side, side); 
    145  
     146             
    146147            glMatrixMode(GL_PROJECTION); 
    147148            glLoadIdentity(); 
     
    154155            lastPos = QPoint(event.pos.x, event.pos.y); 
    155156        } 
    156  
     157         
    157158        void mouseMoveEvent(QMouseEvent event) 
    158159        { 
    159160            int dx = event.x - lastPos.x; 
    160161            int dy = event.y - lastPos.y; 
    161  
     162             
    162163            if (event.buttons() & Qt.LeftButton) { 
    163164                setXRotation(xRot + 8 * dy); 
     
    174175            GLuint list = glGenLists(1); 
    175176            glNewList(list, GL_COMPILE); 
    176  
     177             
    177178            glBegin(GL_QUADS); 
    178  
     179             
    179180            GLdouble x1 = +0.06; 
    180181            GLdouble y1 = -0.14; 
     
    185186            GLdouble x4 = +0.30; 
    186187            GLdouble y4 = +0.22; 
    187  
     188             
    188189            quad(x1, y1, x2, y2, y2, x2, y1, x1); 
    189190            quad(x3, y3, x4, y4, y4, x4, y3, x3); 
    190  
     191             
    191192            extrude(x1, y1, x2, y2); 
    192193            extrude(x2, y2, y2, x2); 
     
    196197            extrude(x4, y4, y4, x4); 
    197198            extrude(y4, x4, y3, x3); 
    198  
     199             
    199200            const double Pi = 3.14159265358979323846; 
    200201            const int NumSectors = 200; 
    201  
     202             
    202203            for (int i = 0; i < NumSectors; ++i) { 
    203204                double angle1 = (i * 2 * Pi) / NumSectors; 
     
    206207                GLdouble x6 = 0.20 * sin(angle1); 
    207208                GLdouble y6 = 0.20 * cos(angle1); 
    208  
     209                 
    209210                double angle2 = ((i + 1) * 2 * Pi) / NumSectors; 
    210211                GLdouble x7 = 0.20 * sin(angle2); 
     
    212213                GLdouble x8 = 0.30 * sin(angle2); 
    213214                GLdouble y8 = 0.30 * cos(angle2); 
    214  
     215                 
    215216                quad(x5, y5, x6, y6, x7, y7, x8, y8); 
    216  
     217                 
    217218                extrude(x6, y6, x7, y7); 
    218219                extrude(x8, y8, x5, y5); 
    219220            } 
    220  
     221             
    221222            glEnd(); 
    222223 
     
    224225            return list; 
    225226        } 
    226  
     227         
    227228        void quad(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2, 
    228229                   GLdouble x3, GLdouble y3, GLdouble x4, GLdouble y4) 
    229230        { 
    230231            qglColor(trolltechGreen); 
    231  
     232             
    232233            glVertex3d(x1, y1, -0.05); 
    233234            glVertex3d(x2, y2, -0.05); 
    234235            glVertex3d(x3, y3, -0.05); 
    235236            glVertex3d(x4, y4, -0.05); 
    236  
     237             
    237238            glVertex3d(x4, y4, +0.05); 
    238239            glVertex3d(x3, y3, +0.05); 
     
    240241            glVertex3d(x1, y1, +0.05); 
    241242        } 
    242  
     243         
    243244        void extrude(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) 
    244245        { 
    245246            qglColor(trolltechGreen.darker(rndint(250 + (100 * x1)))); 
    246  
     247             
    247248            glVertex3d(x1, y1, +0.05); 
    248249            glVertex3d(x2, y2, +0.05); 
     
    250251            glVertex3d(x1, y1, -0.05); 
    251252        } 
    252  
     253         
    253254        void normalizeAngle(int *angle) 
    254255        { 
     
    258259                *angle -= 360 * 16; 
    259260        } 
    260  
     261         
    261262        GLuint object; 
    262263        int xRot; 
  • examples/widgets/analogclock/AnalogClock.d

    r1 r4  
    6565    void paintEvent(QPaintEvent event) 
    6666    { 
    67         static const QPoint[3] hourHand = [ 
     67/*        static const QPoint hourHand[3] = { 
    6868            QPoint(7, 8), 
    6969            QPoint(-7, 8), 
    7070            QPoint(0, -40) 
    71         ]
    72         static const QPoint[3] minuteHand = [ 
     71        }
     72        static const QPoint minuteHand[3] = { 
    7373            QPoint(7, 8), 
    7474            QPoint(-7, 8), 
    7575            QPoint(0, -70) 
    76         ]; 
     76        }; 
     77*/ 
     78        scope hourHand = new QPolygon; 
     79        hourHand.append(QPoint(7, 8)); 
     80        hourHand.append(QPoint(-7, 8)); 
     81        hourHand.append(QPoint(0, -40)); 
     82 
     83        scope minuteHand = new QPolygon; 
     84        minuteHand.append(QPoint(7, 8)); 
     85        minuteHand.append(QPoint(-7, 8)); 
     86        minuteHand.append(QPoint(0, -70)); 
    7787 
    7888        scope hourColor = new QColor(127, 0, 127); 
  • generator/main.cpp

    r1 r4  
    7676    QString pp_file = ".preprocessed.tmp"; 
    7777    QStringList rebuild_classes; 
     78    QString source_dir; 
    7879 
    7980    QMap<QString, QString> args; 
     
    151152    } 
    152153 
     154    source_dir = args.value("source-directory"); 
    153155    fileName = args.value("arg-1"); 
     156    if (!source_dir.isEmpty()) 
     157    { 
     158        fileName = source_dir + "/" + fileName; 
     159    } 
    154160 
    155161    typesystemFileName = args.value("arg-2"); 
     
    173179    printf("Running the QtD Generator. Please wait while source files are being generated...\n"); 
    174180 
    175     if (!TypeDatabase::instance()->parseFile(typesystemFileName)) 
     181    if (!TypeDatabase::instance()->parseFile(typesystemFileName, source_dir)) 
    176182        qFatal("Cannot parse file: '%s'", qPrintable(typesystemFileName)); 
    177183 
    178  
    179     if (!Preprocess::preprocess(fileName, pp_file, args.value("include-paths"))) { 
     184    if (!Preprocess::preprocess(fileName, pp_file, args.value("include-paths"), source_dir, args.value("qt-include-directory"))) { 
    180185        fprintf(stderr, "Preprocessor failed on file: '%s'\n", qPrintable(fileName)); 
    181186        return 1; 
     
    213218    printf( 
    214219           "  --cpp-shared                              \n" 
     220           "  --qt-include-directory                    \n" 
     221           "  --qt-directory                            \n" 
     222           "  --source-directory                        \n" 
    215223           "  --debug-level=[sparse|medium|full]        \n" 
    216            "  --d-target=[d1-tango|d2-phobos]                 \n" 
     224           "  --d-target=[d1-tango|d2-phobos]           \n" 
    217225           "  --dump-object-tree                        \n" 
    218226           "  --help, -h or -?                          \n" 
  • generator/main.h

    r1 r4  
    5050struct Preprocess 
    5151{ 
    52     static bool preprocess(const QString &sourceFile, const QString &targetFile, const QString &commandLineIncludes = QString()) 
     52    static bool preprocess(const QString &sourceFile, const QString &targetFile, const QString &commandLineIncludes = QString(), 
     53                           QString qtdir = QString(), QString qtdir_inc = QString()) 
    5354    { 
    5455        rpp::pp_environment env; 
     
    8788 
    8889        // Include Qt 
    89         QString qtdir_inc = getenv ("QTDIR_INC"); 
    90         QString qtdir = getenv ("QTDIR"); 
     90        if (qtdir.isEmpty()) 
     91            qtdir = getenv ("QTDIR"); 
     92        if (qtdir_inc.isEmpty()) 
     93            qtdir_inc = getenv ("QTDIR_INC"); 
    9194        if (qtdir.isEmpty() && qtdir_inc.isEmpty()) { 
    92             qWarning("QTDIR and(or) QTDIR_INC environment variables not set. This may cause problems with finding the necessary include files."); 
     95            qWarning("QTDIR and QTDIR_INC environment variables not set. This may cause problems with finding the necessary include files."); 
    9396        } else { 
    9497            if (qtdir_inc.isEmpty()) 
     
    101104            includes << qtdir_inc; 
    102105        } 
    103  
    104106 
    105107        foreach (QString include, includes) 
  • generator/typesystem.cpp

    r1 r4  
    139139{ 
    140140public: 
    141     Handler(TypeDatabase *database, bool generate) 
    142         : m_database(database), m_generate(generate ? TypeEntry::GenerateAll : TypeEntry::GenerateForSubclass) 
     141    Handler(TypeDatabase *database, const QString &source_dir, bool generate) 
     142        : m_database(database), m_generate(generate ? TypeEntry::GenerateAll : TypeEntry::GenerateForSubclass), m_source_dir(source_dir) 
    143143    { 
    144144        m_current_enum = 0; 
     
    216216 
    217217    QHash<QString, StackElement::ElementType> tagNames; 
     218 
     219    QString m_source_dir; 
    218220}; 
    219221 
     
    841843                } 
    842844 
    843                 if (!m_database->parseFile(name, convertBoolean(attributes["generate"], "generate", true))) { 
     845                if (!m_database->parseFile(name, m_source_dir, convertBoolean(attributes["generate"], "generate", true))) { 
    844846                    m_error = QString("Failed to parse: '%1'").arg(name); 
    845847                    return false; 
     
    15131515} 
    15141516 
    1515 bool TypeDatabase::parseFile(const QString &filename, bool generate) 
    1516 
    1517     QFile file(filename); 
     1517bool TypeDatabase::parseFile(const QString &filename, const QString &source_dir, bool generate) 
     1518
     1519    QString name; 
     1520    if (source_dir.isEmpty()) 
     1521    name = filename; 
     1522    else 
     1523        name = source_dir + "/" + filename; 
     1524    QFile file(name); 
    15181525    Q_ASSERT(file.exists()); 
    15191526    QXmlInputSource source(&file); 
     
    15221529 
    15231530    QXmlSimpleReader reader; 
    1524     Handler handler(this, generate); 
     1531    Handler handler(this, source_dir, generate); 
    15251532 
    15261533    reader.setContentHandler(&handler); 
  • generator/typesystem.h

    r1 r4  
    11871187    QString filename() const { return "typesystem.txt"; } 
    11881188 
    1189     bool parseFile(const QString &filename, bool generate = true); 
     1189    bool parseFile(const QString &filename, const QString &work_dir, bool generate = true); 
    11901190 
    11911191private: 
  • generator/typesystem_core.xml

    r2 r4  
    19251925 
    19261926  <value-type name="QLine" wrap="struct"/> 
    1927   <value-type name="QLineF" wrap="struct"
     1927  <value-type name="QLineF" wrap="struct"
    19281928        <inject-code> 
    19291929            <import-file name="typesystem_core-java.java" quote-after-line="class QLineF___" quote-before-line="}// class"/>