C++ wasm mvc分层架构

2024-06-12

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139637038

创作不易，小小的支持一下吧！

展开全文 >>

C++ 网络请求库cpr

2024-06-12

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139627776

curl

GitHub - libcpr/cpr: C++ Requests: Curl for People, a spiritual port of Python Requests.

GitHub - psf/requests: A simple, yet elegant, HTTP library.


#include "cpr/cpr.h"
#include "cpr/util.h"
#include <chrono>
using namespace cpr;

// CPR_USE_SYSTEM_CURL
class ChangeRequestMethodToPutInterceptorMulti : public InterceptorMulti {
public:
    std::vector<Response> intercept(MultiPerform& multi) override {
        multi.GetSessions().front().second = MultiPerform::HttpMethod::PUT_REQUEST;
        multi.GetSessions().front().first->SetOption(Payload{ {"x", "5"} });
        return proceed(multi);
    }
};

class HiddenHelloWorldRedirectInterceptor : public Interceptor {
public:
    Response intercept(Session& session) override {
        // Save original url
        Url old_url = session.GetFullRequestUrl();

        // Rewrite the url
        Url url{ "https://api.github.com/repos/whoshuu/cpr/contributors" };
        session.SetUrl(url);

        // Proceed the chain
        Response response = proceed(session);

        // Restore the url again
        response.url = old_url;
        return response;
    }
};

// ErrorCode::OPERATION_TIMEDOUT
// ErrorCode::UNSUPPORTED_PROTOCOL
int status_callback(int& status_code, Response r) {
    status_code = r.status_code;
    return r.status_code;
}

bool write_data(std::string /*data*/, intptr_t /*userdata*/) {
    return true;
}

void InterceptorTest() {
    cpr::Url url{ "https://api.github.com/repos/whoshuu/cpr/contributors" };
    std::shared_ptr<Session> session = std::make_shared<Session>();
    session->SetUrl(url);
    MultiPerform multi;
    multi.AddSession(session);
    multi.AddInterceptor(std::make_shared<ChangeRequestMethodToPutInterceptorMulti>());
    std::vector<Response> response = multi.Get();
}

void test() {
    // GET
    Cookies cookies{
        {"SID", "31d4d96e407aad42", "127.0.0.1", false, "/", true, std::chrono::system_clock::from_time_t(3905119080)},
        {"lang", "en-US", "127.0.0.1", false, "/", true, std::chrono::system_clock::from_time_t(3905119080)},
    };
    Body body{ static_cast<std::string_view>("message=abc123") };
    SslOptions sslOpts = Ssl(ssl::CaInfo{ "ca-bundle.crt" }, ssl::CertFile{ "client.crt" }, ssl::KeyFile{ "client.key" }, ssl::VerifyPeer{ true }, ssl::PinnedPublicKey{"server.pub" }, ssl::VerifyHost{ true }, ssl::VerifyStatus{ false });
    //Resolve resolve{ "www.example.com", "127.0.0.1", {server->GetPort()} };
    cpr::Url url{ "https://api.github.com/repos/whoshuu/cpr/contributors" };
    cpr::Response r = cpr::Get(url, cookies, cpr::ConnectTimeout{ std::chrono::milliseconds{1} },
        Header{ {"key", "value"}, {"hello", "world"}, {"test", "case"} },
        cpr::Authentication{ "user", "pass", cpr::AuthMode::BASIC },
        LimitRate(1024, 1024),
        body,
        sslOpts,
        Verbose{},
        cpr::Parameters{ {"anon", "true"}, {"key", "value"} });
    r.status_code;                  // 200
    r.header["content-type"];       // application/json; charset=utf-8
    r.text;                         // JSON text string
    auto responseProxy = cpr::Get(url, cpr::Proxies{ {"http", "http://bad_host.libcpr.org"} });

    // ASYNC GET
    cpr::AsyncResponse future = cpr::GetAsync(url);
    auto response = future.get();

    // CALLBACK
    int status_code = 0;
    auto callback = std::function<int(Response)>(std::bind(status_callback, std::ref(status_code), std::placeholders::_1));
    //auto future = cpr::GetCallback(callback, url);
    //auto future = cpr::HeadCallback(callback, url);
    //auto future = cpr::PostCallback(callback, url, payload);
    //auto future = cpr::PutCallback(callback, url, payload);
    //auto future = cpr::OptionsCallback(callback, url);
    //auto future = cpr::PatchCallback(callback, url, payload);
    //auto future = cpr::DeleteCallback(callback, url);
    unsigned count = 0;
    //Response response = cpr::Put(url, cpr::ReadCallback{ 3, [&](char* buffer, size_t& size, intptr_t /*userdata*/) -> size_t {
    //                                                        std::string data;
    //                                                        ++count;
    //                                                        switch (count) {
    //                                                            case 1:
    //                                                                data = "x=";
    //                                                                break;
    //                                                            case 2:
    //                                                                data = "5";
    //                                                                break;
    //                                                            default:
    //                                                                return false;
    //                                                        }
    //                                                        std::copy(data.begin(), data.end(), buffer);
    //                                                        size = data.size();
    //                                                        return true;
    //                                                    } });
    response = cpr::Post(url, cpr::ReadCallback{ 3, [&](char* buffer, size_t& size, intptr_t /*userdata*/) -> size_t {
                                                             std::string data;
                                                             ++count;
                                                             switch (count) {
                                                                 case 1:
                                                                     data = "x=";
                                                                     break;
                                                                 case 2:
                                                                     data = "5";
                                                                     break;
                                                                 default:
                                                                     return false;
                                                             }
                                                             std::copy(data.begin(), data.end(), buffer);
                                                             size = data.size();
                                                             return true;
                                                         } });
    response = Post(url, HeaderCallback{ [](std::string /*header*/, intptr_t /*userdata*/) -> bool { return false; } });
    std::string response_text;
    response = Post(url, Payload{ {"x", "5"} }, WriteCallback{ [&response_text](const std::string& header, intptr_t /*userdata*/) -> bool {
             response_text.append(header);
             return true;
         } });
    response = Post(url, ProgressCallback{ [](size_t /*downloadTotal*/, size_t /*downloadNow*/, size_t /*uploadTotal*/, size_t /*uploadNow*/, intptr_t /*userdata*/) -> bool { return false; } });
    std::string debug_body;
    response = Post(url, body, DebugCallback{ [&](DebugCallback::InfoType type, const std::string& data, intptr_t /*userdata*/) {
                                 if (type == DebugCallback::InfoType::DATA_OUT) {
                                     debug_body = data;
                                 }
                             } });

    // ASYNC DOWNLOAD
    //future = cpr::DownloadAsync(fs::path{ "/tmp/aync_download" }, url, cpr::Header{ {"Accept-Encoding", "gzip"} }, cpr::WriteCallback{ write_data, 0 });
    //response = future.get();

    // PUT
    Session session;
    session.SetUrl(url);
    session.SetHeader(cpr::Header{ {"Accept-Encoding", "gzip"} });
    session.SetRange(cpr::Range{ std::nullopt, std::nullopt });
    session.SetPayload({ {"x", "5"} });
    session.SetRedirect(Redirect(false));
    //session.SetMultiRange(cpr::MultiRange{ cpr::Range{std::nullopt, 3}, cpr::Range{5, 6} });
    session.AddInterceptor(std::make_shared<HiddenHelloWorldRedirectInterceptor>());
    response = session.Download(cpr::WriteCallback{ write_data, 0 });
    auto len = session.GetDownloadFileLength();
    Payload payload{ {"x", "5"} };
    response = cpr::Put(url, payload);

    // DELETE
    response = session.Delete();
    response = cpr::Delete(url, cpr::Body{ "'foo': 'bar'" }, cpr::Header{ {"Content-Type", "application/json"} });
    cpr::AsyncResponse future_response = cpr::DeleteAsync(url);

    //Auth
    std::string user = "一二三";
    std::string pass = "Hello World!";
    EncodedAuthentication pa{ user, pass };

    // UPLOAD
    cpr::fs::path filePath = "test_file.txt";
    cpr::Multipart mp{ {cpr::Part("file_name", cpr::File(filePath.string()))} };
    response = cpr::Post(url, mp);

    // Util
    std::string input = "%E4%B8%80%E4%BA%8C%E4%B8%89";
    std::string result = util::urlDecode(input);
}

创作不易，小小的支持一下吧！

展开全文 >>

C++ PDF转图片

2024-06-11

本文已加密，请输入密码后继续阅读。 more >>

展开全文 >>

C++ UML建模

2024-06-11

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139608711

starUML

UML图转C++代码

数据流图

E-R图

流程图

整体架构图

ORM关系图

参考

app.asar附件资源可免激活

JHBlog/设计模式/设计模式/1、StarUML使用简明教程.md at master · SunshineBrother/JHBlog · GitHub

C++程序员UML实务手册代码 - 开发实例、源码下载 - 好例子网

GitHub - dimon4ezzz/whitestaruml: UML modeling tool derived from StarUML compatible with Windows

创作不易，小小的支持一下吧！

展开全文 >>

C++ volatile实现原子性读写

2024-06-10

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139574266

__declspec(selectany) 支持h文件定义全局变量，重复包含不报错

int i = 2; //变量i还是不用加volatile修饰

#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))

#define READ_ONCE(x) ACCESS_ONCE(x)

#define WRITE_ONCE(x, val) ({ ACCESS_ONCE(x) = (val); })

a = READ_ONCE(i);

WRITE_ONCE(i, 2);

volatile仅仅是保证int的地址对齐，而对齐后的×××在现代处理器中，是能够做到原子性读写的。
在C++中volatile具有以下特性：

易变性：
所谓的易变性，在汇编层面反映出来，就是两条语句，
下一条语句不会直接使用上一条语句对应的volatile变量的寄存器内容，而是重新从内存中读取。
“不可优化”性：
volatile告诉编译器，不要对我这个变量进行各种激进的优化，甚至将变量直接消除，保证程序员写在代码中的指令，一定会被执行。
“顺序性”：
能够保证Volatile变量间的顺序性，编译器不会进行乱序优化。Volatile变量与非Volatile变量的顺序，编译器不保证顺序，可能会进行乱序优化。

//CAS作为最基础的RMW操作，其他所有RMW操作都可以通过CAS来实现
bool CAS( int * pAddr, int nExpected, int nNew )
atomically {
if ( *pAddr == nExpected ) {
*pAddr = nNew ;
return true ;
}
else
return false ;
}

//CAS变种
int CAS( int * pAddr, int nExpected, int nNew )
atomically {
if ( *pAddr == nExpected ) {
*pAddr = nNew ;
return nExpected ;
}
else
return *pAddr;
}

//例如 fetch-and-add(FAA)
int FAA( int * pAddr, int nIncr )
{
int ncur = *pAddr;
do {} while ( !compare_exchange( pAddr, ncur, ncur + nIncr ) ;//compare_exchange失败会返回当前值于ncur
return ncur ;
}

在C++11的原子lib中，主要有以下RMW操作：
std::atomic<>::fetch_sub()
std::atomic<>::fetch_and()
std::atomic<>::fetch_or()
std::atomic<>::fetch_xor()
std::atomic<>::exchange()
std::atomic<>::compare_exchange_strong()
std::atomic<>::compare_exchange_weak()

//实现自己需要的原子RMW操作，我们需要一个原子对内存中值执行乘法，也就是 atomic fetch_multiply
uint32_t fetch_multiply(std::atomic<uint32_t>& shared, uint32_t multiplier)
{
uint32_t oldValue = shared.load();
while (!shared.compare_exchange_weak(oldValue, oldValue * multiplier))
{
}
return oldValue;
}

//对结构体进行原子修改
struct Terms
{
uint32_t x;
uint32_t y;
};
std::atomic terms;
void atomicFibonacciStep()
{
Terms oldTerms = terms.load();
Terms newTerms;
do
{
newTerms.x = oldTerms.y;
newTerms.y = oldTerms.x + oldTerms.y;
}
while (!terms.compare_exchange_weak(oldTerms, newTerms));
}

//是不是在内部加了锁
std::atomic<> template包含了一个is_lock_free()成员来用于判断该原子类型是原子操作是否是lock-free的。
—同时满足以下条件的原子类的原子操作才能做出是lock-free的保证

The compiler is a recent version MSVC, GCC or Clang.
The target processor is x86, x64 or ARMv7 (and possibly others).
The atomic type is std::atomic<uint32_t>, std::atomic<uint64_t> or std::atomic<T*> for some type T.

我们必须加上编译器的barrier来防止编译器的乱序优化：
#define COMPILER_BARRIER() asm volatile(“” ::: “memory”)
int Value;
int IsPublished = 0;
void sendValue(int x)
{
Value = x;
COMPILER_BARRIER(); // prevent reordering of stores
IsPublished = 1;
}

int tryRecvValue()
{
if (IsPublished)
{
COMPILER_BARRIER(); // prevent reordering of loads
return Value;
}
return -1; // or some other value to mean not yet received
}

//cache同步
Write Invalidate(置无效)：当一个CPU Core修改了一份数据X，那么它需要通知其他core将他们的cache中的X设置为无效(invalid)
Write Update(写更新)：当一个CPU Core修改了一份数据X，那么它需要通知其他core将他们的cache中的X更新到最新值(如果cache中有的话)

//cache间MESI协议就包含了描述共享的状态
M(Modified): cache line数据有效，但是数据被修改过了，本Cache中的数据是最新的，内存的数据是老的，需要在适当时候将Cache数据写回内存。该cache将数据及其控制权传递到其他cache中，或者cache需要负责将数据写回到memory中，而这些操作都需要在reuse该cache line之前完成。
E(Exclusive)：cache line数据有效，并且cache和memory中的数据是一致的，同时数据只在本cache中有效。直接reuse该cacheline（将cacheine中的数据丢弃，用作他用）
S(Shared)：cache line的数据有效，并且cache和memory中的数据是一致的，同时该数据在多个cpu cache中也是有效的。直接reuse该cacheline（将cacheine中的数据丢弃，用作他用）
I(Invalid)：本cache line的数据已经是无效的。处于invalid状态的cacheline是空的，没有数据。当新的数据要进入cache的时候，优选状态是invalid的cacheline，之所以如此是因为如果选中其他状态的cacheline，则说明需要替换cacheline数据，而未来如果再次访问这个被替换掉的cacheline数据的时候将遇到开销非常大的cache miss。

//在MESI协议中，每个CPU都会监听总线(bus)上的其他CPU对每个Cache line的所有操作，因此该协议也称为监听(snoop)协议
通常情况下，CPU需要以下几个通信message即可：
Read消息：read message用来获取指定物理地址上的cacheline数据
Read Response消息：该消息携带了read message请求的数据。read response可能来自memory，也可能来自其他的cache。例如：如果一个cache有read message请求的数据并且该cacheline的状态是modified，那么该cache必须以read response回应这个read message，因为该cache中保存了最新的数据。
Invalidate消息：该命令用来将其他cpu cache中的数据设定为无效。该命令携带物理地址的参数，其他CPU cache在收到该命令后，必须进行匹配，发现自己的cacheline中有该物理地址的数据，那么就将其移除并用Invalidate Acknowledge回应。
Invalidate Acknowledge消息：收到invalidate message的cpu cache，在移除了其cache line中的特定数据之后，必须发送invalidate acknowledge消息。
Read Invalidate消息：该message中也包括了物理地址这个参数，以便说明其想要读取哪一个cacheline数据。此外，该message还同时有invalidate message的功效，即其他的cache在收到该命令后，移除自己cacheline中的数据。因此，Read Invalidate message实际上就是read＋invalidate。发送Read Invalidate之后，cache期望收到一个read response以及多个invalidate acknowledge。
Writeback消息：该message包括两个参数，一个是地址，另外一个是写回的数据。该消息用在modified状态的cacheline被驱逐出境（给其他数据腾出地方）的时候发出，该命名用来将最新的数据写回到memory（或者其他的CPU cache中）

##Store Buffer
在CPU和cache之间增加store buffer这个HW block。
那么cpu 0无需等待其他CPU的相应，只需要将要修改的内容放入store buffer，然后继续执行就OK了。当cache line完成了bus transaction，并更新了cache line的状态后，要修改的数据将从store buffer进入cache line。
这种设计叫做store forwarding，当CPU执行load操作的时候，不但要看cache，还有看store buffer是否有内容，如果store buffer有该数据，那么就采用store buffer中的值。store forwarding解决了CPU 0的cache line和store buffer间的数据一致性问题。
smp_mb内存屏障。保证多核CPU的store buffer内容一致，保证store buffer完全写入cache line之前，其他数据不能先更新cache line。

###为了保证MESI协议的正确性，CPU在需要发出某个变量的a的MESI协议消息的时候，需要检查invalidate queue中是否有该变量a的invalidate消息，如果有需要先出来完成这个invliadte消息后，才能发出正确的MESI协议消息。

#无论哪一种cpu都遵守下面的规则：
[1]、从CPU自己的视角看，它自己的memory order是服从program order的
[2]、从包含所有cpu的sharebility domain的角度看，所有cpu对一个共享变量的访问应该服从若干个全局存储顺序
[3]、memory barrier需要成对使用
[4]、memory barrier的操作是构建互斥锁原语的基石

创作不易，小小的支持一下吧！

支付宝

展开全文 >>

C#项目实战

2024-06-10

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139573246

事件

public delegate void NumManipulationHandler(NumEventArgs e);
// 基于上面的委托定义事件
public event NumManipulationHandler ChangeNum;
 public class Program
    {
        public static void Main()
        {

            NumEvent even = new NumEvent(0);
            even.ChangeNum += EventAction.Action;

            even.SetValue(7);
            even.SetValue(11);

            System.Console.ReadKey();
        }
    }

    public class NumEvent
    {
        private int value;

        public delegate void NumManipulationHandler(NumEventArgs e);

        public event NumManipulationHandler ChangeNum;

        public virtual void OnChangeNum(NumEventArgs e)
        {
            ChangeNum?.Invoke(e);
        }

        public NumEvent(int n)
        {
            SetValue(n);
        }

        public void SetValue(int n)
        {
            if (value != n)
            {
                NumEventArgs e = new NumEventArgs(n);
                value = n;
                OnChangeNum(e);
            }
        }
    }

    public class EventAction
    {
        public static void Action(NumEventArgs e)
        {
            System.Console.WriteLine("value : " + e.value);
        }
    }

    public class NumEventArgs : EventArgs
    {
        public int value;
        public NumEventArgs(int _value)
        {
            this.value = _value;
        }
    }

ini读写

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Linq;
using System.Text;

namespace DEMOBus
{
    public class IniFile
    {
        private string m_FileName;

        public string FileName
        {
            get { return m_FileName; }
            set { m_FileName = value; }
        }

        [DllImport("kernel32.dll")]
        private static extern int GetPrivateProfileInt(
            string lpAppName,
            string lpKeyName,
            int nDefault,
            string lpFileName
            );

        [DllImport("kernel32.dll")]
        private static extern int GetPrivateProfileString(
            string lpAppName,
            string lpKeyName,
            string lpDefault,
            StringBuilder lpReturnedString,
            int nSize,
            string lpFileName
            );

        [DllImport("kernel32.dll")]
        private static extern int WritePrivateProfileString(
            string lpAppName,
            string lpKeyName,
            string lpString,
            string lpFileName
            );

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="aFileName">Ini文件路径</param>
        public IniFile(string aFileName)
        {
            this.m_FileName = aFileName;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        public IniFile()
        { }

        /// <summary>
        /// [扩展]读Int数值
        /// </summary>
        /// <param name="section">节</param>
        /// <param name="name">键</param>
        /// <param name="def">默认值</param>
        /// <returns></returns>
        public int ReadInt(string section, string name, int def)
        {
            return GetPrivateProfileInt(section, name, def, this.m_FileName);
        }

        /// <summary>
        /// [扩展]读取string字符串
        /// </summary>
        /// <param name="section">节</param>
        /// <param name="name">键</param>
        /// <param name="def">默认值</param>
        /// <returns></returns>
        public string ReadString(string section, string name, string def)
        {
            StringBuilder vRetSb = new StringBuilder(2048);
            GetPrivateProfileString(section, name, def, vRetSb, 2048, this.m_FileName);
            return vRetSb.ToString();
        }

        /// <summary>
        /// [扩展]写入Int数值，如果不存在 节-键，则会自动创建
        /// </summary>
        /// <param name="section">节</param>
        /// <param name="name">键</param>
        /// <param name="Ival">写入值</param>
        public void WriteInt(string section, string name, int Ival)
        {

            WritePrivateProfileString(section, name, Ival.ToString(), this.m_FileName);
        }

        /// <summary>
        /// [扩展]写入String字符串，如果不存在 节-键，则会自动创建
        /// </summary>
        /// <param name="section">节</param>
        /// <param name="name">键</param>
        /// <param name="strVal">写入值</param>
        public void WriteString(string section, string name, string strVal)
        {
            WritePrivateProfileString(section, name, strVal, this.m_FileName);
        }

        /// <summary>
        /// 删除指定的 节
        /// </summary>
        /// <param name="section"></param>
        public void DeleteSection(string section)
        {
            WritePrivateProfileString(section, null, null, this.m_FileName);
        }

        /// <summary>
        /// 删除全部 节
        /// </summary>
        public void DeleteAllSection()
        {
            WritePrivateProfileString(null, null, null, this.m_FileName);
        }

        /// <summary>
        /// 读取指定 节-键 的值
        /// </summary>
        /// <param name="section"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public string IniReadValue(string section, string name)
        {
            StringBuilder strSb = new StringBuilder(256);
            GetPrivateProfileString(section, name, "", strSb, 256, this.m_FileName);
            return strSb.ToString();
        }

        /// <summary>
        /// 写入指定值，如果不存在 节-键，则会自动创建
        /// </summary>
        /// <param name="section"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public void IniWriteValue(string section, string name, string value)
        {
            WritePrivateProfileString(section, name, value, this.m_FileName);
        }
    }
}

绘图

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace _949CS//实时曲线绘制
{
    class draw
    {
        public List<Point> ptlist = new List<Point> { new Point(0, 0)};
        public PictureBox picbox = new PictureBox();
        public Bitmap mybitmap;//用于双缓冲的位图，和画布等大
        public Int32 xMoveToUp = 0, yMoveToRight = 0;     //X上移距离与Y右移距离
        public Int32 xToLeft = 5, xToRight = 10, yToUp = 5, yToDown = 5; //XY图像边距,x轴起点离左边距，终点右边距，y轴起点下边距，上边距，Y轴坐标为从上往下递增值
        public void DrawLineS(Color color, float Xmax, float Ymax)
        {
            if (ptlist.Count < 2)
            {//空返回
                return;
            }
            mybitmap = new Bitmap(picbox.Width, picbox.Height);//设定位图大小
            Graphics doublebufferg = Graphics.FromImage(mybitmap);//从位图上获取“画布”
            doublebufferg.Clear(Color.Black);//用背景色刷新

            //picbox填充为白色，便于显示图像  500*300
            Rectangle rect = new Rectangle(0, 0, picbox.Width, picbox.Height);
            doublebufferg.FillRectangle(new SolidBrush(Color.Black), rect);
             
            //画X和Y轴
            DrawXY(ref doublebufferg, picbox);
            //X轴上的刻度
            SetYAxis(ref doublebufferg, picbox, Ymax);
            //Y轴上的刻度
            SetXAxis(ref doublebufferg, picbox, Xmax);

            Point[] pt = ptlist.ToArray();
            Int32 i = 0;
            for (i = 0; i < pt.Length; i++)
            {
                pt[i].X += xToLeft + yMoveToRight;//自定义坐标转换
                pt[i].Y = picbox.Height - yToDown - xMoveToUp - pt[i].Y;
                if (i > 0)
                {
                    //要显示的实时曲线部分
                    doublebufferg.DrawLine(new Pen(color, 1), pt[i - 1], pt[i]);
                }
            }
            //将缓冲中的位图绘制到我们的窗体上
            if (!picbox.IsDisposed)
            {   //是够释放
                picbox.BackColor = Color.Black;     //背景色直接设置
                (picbox.CreateGraphics()).DrawImage(mybitmap, 0, 0);
            }
        } 
        //X上移
        public void  SetMoveX(Int32 x)
        {
            xMoveToUp = x;
        }
        //Y右移
        public void  SetMoveY(Int32 y)
        {
            yMoveToRight = y;
        }
        //完成X轴和Y轴的基本部分
        public void  DrawXY(ref Graphics g,PictureBox picbox)
        {
            Pen pen = new Pen(Color.White, 2);//画笔
            SolidBrush sb = new SolidBrush(Color.White);//话刷
            
            //X轴的箭头，实际上是绘制了一个三角形
            Int32 arrorWidth = 5, arrorHeight = 2;   //箭头的三角形中位线长与底边长一半
            Point[] xpts = new Point[3] {   //自定义坐标转换
                new Point(picbox.Width - (xToRight + arrorWidth), picbox.Height - (arrorHeight + yToDown + xMoveToUp)),
                new Point(picbox.Width - xToRight, picbox.Height - yToDown - xMoveToUp),
                new Point(picbox.Width - (xToRight + arrorWidth), picbox.Height + arrorHeight - yToDown - xMoveToUp)
                                        };

            g.DrawLine(pen, xToLeft, picbox.Height - yToDown - xMoveToUp, picbox.Width - xToRight, picbox.Height - yToDown - xMoveToUp);
            g.DrawPolygon(pen, xpts);//自定义坐标转换
            g.DrawString("X", new Font("宋体", 11), sb, picbox.Width - (xToRight), picbox.Height - (yToDown + xMoveToUp));

            //Y轴的箭头，实际上是绘制了一个三角形
            Point[] ypts = new Point[3] { //自定义坐标转换
                     new Point(xToLeft + yMoveToRight - arrorHeight, yToUp + arrorHeight),
                     new Point(xToLeft + yMoveToRight, yToUp), 
                     new Point(xToLeft + yMoveToRight + arrorHeight, yToUp + arrorHeight)
                      };

            g.DrawLine(pen, xToLeft + yMoveToRight, picbox.Height - yToDown, xToLeft + yMoveToRight, yToUp);
            g.DrawPolygon(pen, ypts);//自定义坐标转换
            g.DrawString("Y", new Font("宋体", 11), sb, yMoveToRight + xToLeft + arrorHeight, 0);
        
        }

        //绘制Y轴上的刻度
        public void SetYAxis(ref Graphics g,PictureBox picbox, float YMAX)
        {
            Pen p1 = new Pen(Color.Goldenrod, 1);
            Pen p2 = new Pen(Color.White, 2);
            SolidBrush sb = new SolidBrush(Color.White);

            float ykedu = YMAX / 200;//给定的最大刻度与实际像素的比例关系=,未优化，目前为1:1
            //第一个刻度的两个端点
            float xl = xToLeft - 3 + yMoveToRight, yl = picbox.Height - yToUp, xr = xToLeft + 3 + yMoveToRight, yr = picbox.Height - yToDown;//自定义坐标转换
            for (int j = 0; j < picbox.Height - (yToDown + yToUp); j += 10)
            {
                if (j % 50 == 0)//一个大的刻度，黑色，每隔50像素一个
                {
                    g.DrawLine(p2, xl, yl - j, xr, yl - j);//刻度线
                    string tempy = ((j - xMoveToUp - yToDown) * ykedu).ToString();//自定义坐标转换
                    g.DrawString(tempy, new Font("宋体", 8), sb, xl - 20, yl - j - 5);
                }
                else//小刻度，金黄色，10像素一个
                { g.DrawLine(p1, xl, yl - j, xr, yl - j); }
            }
        }



        //绘制x轴上的刻度
        public void SetXAxis(ref Graphics g,PictureBox picbox, float XMAX)
             {
              Pen p1 = new Pen(Color.Goldenrod, 1);
              Pen p2 = new Pen(Color.White, 2);
              SolidBrush sb = new SolidBrush(Color.White);

              float xkedu = XMAX / 400;  //比例关系未优化，目前为1:1
              float xt = xToLeft, yt = picbox.Height - yToDown - 3 - xMoveToUp, xb = xToLeft, yb = picbox.Height - yToDown + 3 - xMoveToUp;
              //自定义坐标转换
              for (int i = 0; i < picbox.Width - (xToLeft + xToRight); i += 10)
            {

                if (i % 50 == 0)
                {
                    g.DrawLine(p2, xt + i, yt, xb + i, yb);
                    string tempx = ((i - yMoveToRight - xToLeft) * xkedu).ToString();//自定义坐标转换
                    g.DrawString(tempx, new Font("宋体", 8), sb, xt + i - 7, picbox.Height - 25 - xMoveToUp);
                }
                else 
                { g.DrawLine(p1, xt + i, yt, xb + i, yb); }
            }
             }
        
        }

    }

CListCtrlEx重载

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace ADT_LISTVIEW
{
    enum LIST_TYPE
    {
        NO_TYPE = -1,
        EDIT_TYPE = 0,
        CBO_TYPE = 1,
    }
    class ListViewEx : ListView
    {
        private TextBox m_tb;
        private ComboBox m_cb;
        private bool m_bCheckBox;
        private Int32[ ] m_lst = new Int32[20];     //支持最大列数20
        private string[] m_str = new string[20];       //最大列字符串20
        public void SetChekBox(bool bCheck)
        { m_bCheckBox = bCheck; }
        public void AddCboString(String str) {
            string[] param = str.Split(':');
            m_cb.Items.Clear();
            foreach (string i in param)
            {
                m_cb.Items.Add(i);
            }
            m_cb.SelectedIndex = 0;
        }
        public void SetListType(int nIndex, int type)
        {
            m_lst[nIndex] = type;        }
        public int FindStringInCbo(int nCol, string str)
        {
            if (m_lst[nCol] != 1)
            {
                return -1;
            }
            else
            {
                AddCboString(m_str[nCol]);
                return m_cb.FindString(str, -1);
            }
        }
        public ListViewEx()
        {
            m_tb = new TextBox();
            m_cb = new ComboBox();
            m_tb.Multiline = false;
            m_tb.Visible = false;
            m_cb.Visible = false;
            m_cb.DropDownStyle = ComboBoxStyle.DropDownList;
            m_cb.IntegralHeight = true;
            this.GridLines = true;
            this.CheckBoxes = true;
            this.FullRowSelect = false;
            SetChekBox(this.CheckBoxes);
            this.Controls.Add(m_tb);
            this.Controls.Add(m_cb);
            for (int i = 0; i < 20; i++)
            {
                SetListType(i, 0);
            }
            SetStyle(ControlStyles.DoubleBuffer | ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);  //解决ListView闪烁问题
        }
        public void Insert(int nIndex, ListViewItem item)
        {
            for (int i = 0; i < item.SubItems.Count; i++ )
            {   //保存所有列字符——最多20
                m_str[i] = item.SubItems[i].Text;
                if (m_str[i].IndexOf(':') > 0)
                {
                    SetListType(i, 1);
                    AddCboString(m_str[i]);
                    item.SubItems[i].Text = m_cb.Text;
                }
                else
                {
                    SetListType(i, 0);
                }
            }
            this.Items.Insert(nIndex, item);
        }
        private void EditItem(ListViewItem.ListViewSubItem subItem)
        {
            if (this.SelectedItems.Count <= 0)
            {
                return;
            }
            Rectangle _rect = subItem.Bounds;
            m_tb.Bounds = _rect;
            ListViewItem lvi = this.SelectedItems[0];   //选中的多行第0行
            if (subItem == lvi.SubItems[0] || 0 == subItem.Bounds.X)
            {   //第一列为复选框
                if (m_bCheckBox)
                {
                    return;
                }
                else
                {   //修复宽度
                    m_tb.Width = this.Columns[0].Width;
                }
            }
            m_tb.BringToFront();
            m_tb.Text = subItem.Text;
            m_tb.Leave += new EventHandler(tb_Leave);
            m_tb.TextChanged += new EventHandler(m_tb_TextChanged);
            m_tb.Visible = true;
            m_tb.Tag = subItem;
            m_tb.Select();
        }

        private void EditItem(ListViewItem.ListViewSubItem subItem, Rectangle rt)
        {
            if (this.SelectedItems.Count <= 0)
            {
                return;
            }
            Rectangle _rect = rt;
            m_cb.Bounds = _rect;
            m_cb.BringToFront();
           // m_cb.Items.Add(subItem.Text);
            m_cb.Text = subItem.Text;
            m_cb.Leave += new EventHandler(lstb_Leave);
            m_cb.TextChanged += new EventHandler(m_lstb_TextChanged);
            m_cb.DropDownClosed += new EventHandler(m_lstb_TextChanged);
            m_cb.DropDown += new EventHandler(m_lstb_DropDown);
            m_cb.LostFocus += new EventHandler(lstb_Lost);
            m_cb.Visible = true;
            m_cb.Tag = subItem;
            m_cb.Select();
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
//             if (e.KeyCode == Keys.F2)
//             {
// 
//                 if (this.SelectedItems.Count > 0)
//                 {
//                     this.SelectedItems[1].BeginEdit();
//                     ListViewItem lvi = this.SelectedItems[0];
//                     EditItem(lvi.SubItems[0], new Rectangle(lvi.Bounds.Left, lvi.Bounds.Top, this.Columns[0].Width, lvi.Bounds.Height - 2));
//                 }
//             }
            base.OnKeyDown(e);
        }

        protected override void OnSelectedIndexChanged(EventArgs e)
        {
            this.m_tb.Visible = false;
            this.m_cb.Visible = false;
            base.OnSelectedIndexChanged(e);
        }
        protected override void OnDoubleClick(EventArgs e)
        {
            Point tmpPoint = this.PointToClient(Cursor.Position);
            ListViewItem.ListViewSubItem subitem = this.HitTest(tmpPoint).SubItem;
            ListViewItem item = this.HitTest(tmpPoint).Item;
            if (subitem != null)
            {
                int nIndex = 0;
                item.Checked = !item.Checked;       //修复双击时反选功能
                if (0 == subitem.Bounds.X)
                {//修复第一列
                    nIndex = 0;
                }
                else
                {
                    nIndex = this.SelectedItems[0].SubItems.IndexOf(subitem);
                    if (nIndex > this.Columns.Count)
                    {   //修复频繁点击时索引不更新bug
                        base.OnDoubleClick(e);
                        return;
                    }
                 }
                if (0 == m_lst[nIndex])
                 {  //类型选择,编辑框
                     EditItem(subitem);
                 }
                else if (1 == m_lst[nIndex])
                 {  //组合框
                     AddCboString(m_str[nIndex]);
                     EditItem(subitem, new Rectangle(subitem.Bounds.Left, subitem.Bounds.Top, this.Columns[nIndex].Width, subitem.Bounds.Height - 2));
                 }
                else
                {
                    ;
                }
                //item.Checked = !item.Checked;
            }
            base.OnDoubleClick(e);
        }
//         protected override void OnDrawColumnHeader(DrawListViewColumnHeaderEventArgs e)
//         {
//             m_cb.Hide();
//             base.OnDrawColumnHeader(e);
//         }
        protected override void WndProc(ref   Message m)
        {
            if (m.Msg == 0x115 || m.Msg == 0x114)
            {
                this.m_tb.Visible = false;
                this.m_cb.Visible = false;
            }
            base.WndProc(ref   m);
        }

        private void tb_Leave(object sender, EventArgs e)
        {
            m_tb.TextChanged -= new EventHandler(m_tb_TextChanged);
            (sender as TextBox).Visible = false;
        }

        private void m_tb_TextChanged(object sender, EventArgs e)
        {
            if ((sender as TextBox).Tag is ListViewItem.ListViewSubItem)
            {
                (this.m_tb.Tag as ListViewItem.ListViewSubItem).Text = this.m_tb.Text;
            }

        }
        private void lstb_Leave(object sender, EventArgs e)
        {
            m_cb.TextChanged -= new EventHandler(m_lstb_TextChanged);
            m_cb.DropDownClosed -= new EventHandler(m_lstb_TextChanged);
            m_cb.DropDownClosed -= new EventHandler(m_lstb_DropDown);
            m_cb.DropDown -= new EventHandler(m_lstb_DropDown);
            m_cb.LostFocus -= new EventHandler(lstb_Lost);
        }

        private void m_lstb_TextChanged(object sender, EventArgs e)
        {
            if ((sender as ComboBox).Tag is ListViewItem.ListViewSubItem)
            {
                (this.m_cb.Tag as ListViewItem.ListViewSubItem).Text = this.m_cb.Text;
            }
        }
        private void m_lstb_DropDown(object sender, EventArgs e)
        {
            if ((sender as ComboBox).Tag is ListViewItem.ListViewSubItem)
            {
                this.m_cb.Text = (this.m_cb.Tag as ListViewItem.ListViewSubItem).Text;
            }
        }
        private void lstb_Lost(object sender, EventArgs e)
        {
            m_cb.Hide();    //隐藏
            lstb_Leave(sender, e);
        }
        
    }
}

参考

FastTunnel: 开源免费跨平台内网穿透远程内网电脑自定义域名访问内网站点反向代理内网服务 http代理类花生壳端口转发微信小程序 frp NAT ssh proxy tunnel ngork

GitHub - HandyOrg/HandyControl: Contains some simple and commonly used WPF controls

https://github.com/OfficeDev/Image-FileHandler

https://github.com/probot/no-response

https://github.com/dotnet/Open-XML-SDK

https://github.com/OfficeDev/PnP-WOPI

https://github.com/OfficeDev/Open-XML-SDK

https://github.com/OfficeDev/Excel-IO

GitHub - cnxy/files-uwp: A modern file explorer that pushes the boundaries of the platform.

GitHub - OfficeDev/office-fluent-ui-command-identifiers: Office Fluent User Interface Control Identifiers

Code of Conduct | Microsoft Open Source

https://github.com/CollaboratingPlatypus/PetaPoco

https://www.cnblogs.com/zhangweizhong/p/3718549.html

NuGet Gallery | PetaPoco 5.1.304

https://www.cnblogs.com/zhangweizhong/category/855479.html

https://www.cnblogs.com/zhangweizhong/category/771056.html

https://github.com/LonelyCodelang?tab=repositories

https://worktile.com/share/files/64a3b9c8ec0a4d3d81b89a630177c880

https://github.com/statianzo/PostLog

https://www.cnblogs.com/zhangweizhong/category/771055.html

https://github.com/statianzo/Fleck

https://github.com/EasyHttp/EasyHttp

GitHub - Tencent/xLua: xLua is a lua programming solution for C# ( Unity, .Net, Mono) , it supports android, ios, windows, linux, osx, etc.

QJ_FileCenter: 企捷Lotus文件管理平台是开源文档管理平台/企业网盘，支持企业文件、个人文件等文件分库管理，平台能够满足统一存储、文件共享功能。并提供文件上传、目录维护、重命名、移动、复制、删除、预览、等功能。

需ngnix反向代理，账号admin,密码abc123.搭建个人云盘

企捷科技 - 企捷科技

https://gitee.com/dotnetchina/BootstrapAdmin

dotNET China: 让 .NET 开发更简单，更通用，更流行。

GitHub - files-community/Files: Building the best file manager for Windows

GitHub - MMmmmoko/Bongo-Cat-Mver: An Bongo Cat overlay written in C++

创作不易，小小的支持一下吧！

展开全文 >>

C++ 高性能爬虫

2024-06-09

本文已加密，请输入密码后继续阅读。 more >>

展开全文 >>

VUE + nodejs实战

2024-06-09

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139567313

BVDN搭建

D:
cd nodejs
::npm install bootstrap
::npm install jquery
::npm install popper.js
::npm install vue
npm install vue-router
pause

app.html

<!DOCTYPE html>
<!DOCTYPE html>
<html>
<head>
	<!--bootstrap-->
	<link rel="stylesheet" href="/static/css/bootstrap.css">
	<link rel="stylesheet" href="/static/css/bootstrap-theme.css">
	<script src="/static/js/jquery.js"></script>
	<script src="/static/js/bootstrap.js"></script>	
	<!--vue-->
	<script src="/static/js/vue.js"></script>	
	<title>My First Page</title>
</head>
<body>
<nav class="navbar navbar-inverse">
	<ul class="navbar-header">
		<a href="#">My First Page</a>
		<div></div>
	</ul>
</nav>

<div class="container container-center jumbotron">
	<div class="col-sm-4">
	<div id="app" class="form-group">
		<p class="form-contrl" v-text="aaa"></p>
		<span>Input here:</span>
		<input class="form-contrl" v-model='aaa'>	
	</div>	

	</div>

</div>
</body>
<script type="text/javascript">
	var vm = new Vue({
			el: '#app',
			data: {
				aaa: '',
			}
	})
</script>
</html>

firstPage.html

<!DOCTYPE html>
<html>
	<head>
		<title>
			Example
		</title>
		<link href = './asserts/style.css' rel = 'stylesheet' type='text/css'>
	</head>
	<body>
		<div class='site-hdeader'>
			<p class='site-title'>Trutle Ipsum</p>
			<p class=''site-subtitle'>The World's Premier T</p>
		</div>
		<div class='main-nav'>
			<p class "nav-header">Resources</p>
			<div class='nav-list'>
			<p class='nav-item nav-item-bull'><a href='https://www.youtube.com/watch?v=CMNry4PE93Y'> I like Tube</a></p>
			<p class='nav-item nav-item-bull'><a href='https://en.wikipedia.org/wiki/Turtle'>Basic Turtle Info</a></p>
			<p class='nav-item nav-item-bull'><a href='https://en.wikipedia.org/wiki/Turtles_(chocolate)'>Chocolate Turtles</a></p>
			</div>
		</div>
		<div class='main-content'>
			<div>
				<p class='page-title'>Welcome to Turtle Ipsum.
				</a href=''>Click here</a>to learn more.
				</p>
				<p class='acticle-text'>Turtle ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum
				</p>
			</div>
		</div>
		<div class='footer'>
			<div class='footer-section'>
				<span class='button'>Sign up for turtle news</span>
			</div>
			<div class='footer-section'>
				<p class='page-title'>
				 Internal Pages
				</p>
				<div class='nav-list'>
					<p class='nav-item nav-item-bull'><a href='../'>index</a></p>
					<p class='nav-item nav-item-bull'><a href='../semantic'>Semantic Example</a></p>
				</div>
			</div>
			<p class='fotter-copyright'>&copy; 2016 Instrument</p>
		</div>
	</body>
</html>

<script>
	function add(a, b = 1)
	{
		return a+b;
	}
	function sub(c, d)
	{
		return c-d;
	}
	console.log("add :${add(1+1)}");
</script>

插件

https://github.com/Sneezry/chrome_extensions_and_apps_programming
综述–扩展开发文档

https://developer.chrome.com/extensions/manifest

{
“app”: {
“background”: {
“scripts”: [“background.js”]
}
},
“manifest_version”: 2,
“name”: “My Extension”,
“version”: “versionString”,
“default_locale”: “en”,
“description”: “A plain text description”,
“icons”: {
“16”: “images/icon16.png”,
“48”: “images/icon48.png”,
“128”: “images/icon128.png”
},
“browser_action”: {
“default_icon”: {
“19”: “images/icon19.png”,
“38”: “images/icon38.png”
},
“default_title”: “Extension Title”,
“default_popup”: “popup.html”
},
“page_action”: {
“default_icon”: {
“19”: “images/icon19.png”,
“38”: “images/icon38.png”
},
“default_title”: “Extension Title”,
“default_popup”: “popup.html”
},
“background”: {
“scripts”: [“background.js”]
},
“content_scripts”: [
{
“matches”: [“http://www.google.com/\*"\],
“css”: [“mystyles.css”],
“js”: [“jquery.js”, “myscript.js”]
}
],
“options_page”: “options.html”,
“permissions”: [
“*://www.google.com/\*”
],
“web_accessible_resources”: [
“images/*.png”
]
}

node-sass

npm install -d node-sass@4.12.0 –registry=https://registry.npm.taobao.org –SASS_BINARY_SITE=https://npm.taobao.org/mirrors/node-sass/ –PHANTOMJS_CDNURL=https://npm.taobao.org/mirrors/phantomjs/

参考

GitHub - liuyanghejerry/painttyServer: This is server of Mr.Paint, 茶绘君, located at http://mrspaint.com

GitHub - deanhume/progressive-web-apps-book: All of the code for “Progressive Apps” - a book by Dean Hume

GitHub - qmlweb/qmlweb: A QML engine in a web browser. Current state: fixing things…

vue2-elm: 基于 vue2 + vuex 构建一个具有 45 个页面的大型单页面应用
 Orchid-02/基于bootstarp的仿京东购物首页大二实训

GitHub - changkun/changkun-blog-clients: Changkun’s Blog Desktop&Mobile Client

https://blog.csdn.net/luanpeng825485697/column/info/17191

https://github.com/sashafierce/pdf.js

https://github.com/public-apis/public-apis

https://tauri.studio/en/docs/getting-started/setup-windows

https://github.com/zhaojun1998/zfile

https://gitee.com/docmirror/dev-sidecar

https://github.com/avwo/whistle

https://github.com/jspreadsheet/ce

https://github.com/bnoordhuis/gyp/blob/master/test/additional-targets/src/all.gyp

核心小程序商城系统（CoreShop）: 基于 Asp.Net Core 5.0、Uni-App开发，支持可视化布局的小程序商城系统，前后端分离，支持分布式部署，跨平台运行，拥有分销、代理、团购、拼团、秒杀、直播、优惠券、自定义表单等众多营销功能，拥有完整SKU、下单、售后、物流流程。支持一套代码编译发布微信小程序版、H5版、Android版、iOS版、支付宝小程序版、字节跳动小程序版、QQ小程序版等共10个平台。

https://gitee.com/fanjiatian/pc-end-qq

https://gitee.com/fanjiatian/contour-waterfall

学习CSS布局

http://css.doyoe.com/

https://github.com/chadluo/CSS-Guidelines/blob/master/README.md

https://developer.mozilla.org/zh-CN/docs/Web/CSS/CSS_Lists_and_Counters/Using_CSS_counters

https://github.com/CNOliverZhang/PotatofieldImageToolkit/

https://github.com/jgraph/drawio-diagrams

https://github.com/ImageGlass

https://github.com/atom/atom

GitHub - electron/electron-api-demos: Explore the Electron APIs

https://github.com/microsoft/Web-Dev-For-Beginners

Orchid-02/基于Vue调用网易云音乐API的在线音乐播放WebApp

https://gitee.com/Orchid-02/WebStoping

快速开始 | Tauri Apps

https://github.com/FortAwesome/Font-Awesome

Lighthouse首页、文档和下载 - 自动化网络审查工具 - OSCHINA - 中文开源技术交流社区

Color Safe - accessible web color combinations

JavaScript | CSS-Tricks - CSS-Tricks

Operator Lookup - Search JavaScript operators

Flexbox Froggy - A game for learning CSS flexbox

Grid Garden - A game for learning CSS grid | Codepip

https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API

“align-items” | Can I use… Support tables for HTML5, CSS3, etc

Live Server - Visual Studio Marketplace

https://developer.mozilla.org/en-US/docs/Web/Events

https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API

https://github.com/collections/javascript-game-engines

Microsoft Azure PlayFab | Full Stack LiveOps, Real-time Control

https://codepen.io/gsarig/pen/gOwXpRa

iView / View Design 一套企业级 UI 组件库和前端解决方案

https://github.com/nuxt/nuxt.js

https://github.com/kazupon/vue-i18n

Layout 布局 (组件) - Element UI 中文开发手册 - 开发者手册 - 腾讯云开发者社区-腾讯云

https://iviewui.com/components/pro/word-count

渐进式网络应用程序 - Webpack 中文文档 - 开发文档 - 文江博客

webpack 中使用 workbox 实现 PWA_webpack workbox!-CSDN博客

https://unpkg.com/electron-releases@3.646.0/lite.json

https://github.com/docmirror/dev-sidecar

GitHub - RelaxedJS/ReLaXed: Create PDF documents using web technologies

GitHub - jzj1993/jquery.popup: 一款简单易用的网页弹窗插件

创作不易，小小的支持一下吧！

展开全文 >>

C++ MPI多进程并发

2024-06-09

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139566971

下载

用法

mpiexec -n 8 $PROCESS_COUNT x64\Debug\$TARGET.exe 多进程并发启动

mpiexec -f hosts.txt -n 3 $PROCESS_COUNT x64\Debug\$TARGET.exe 联机并发进程，其它联机电脑需在相同路径下有所有程序

//hosts.txt

192.168.86.16
192.168.86.123
192.168.86.108

Demo

#include <stdio.h>
#include <string.h>       // For strlen() function
#include <mpi.h>          // For MPI programming functions
#define MAX_STRING (100)

int _tmain(int argc, _TCHAR* argv[])
{
	char greeting[MAX_STRING];
	int comm_sz;            // Number of processes
	int my_rank;            // My process rank

	MPI_Init(NULL, NULL);
	MPI_Comm_size(MPI_COMM_WORLD, &comm_sz);
	MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);

	if (my_rank != 0)
	{
		sprintf(greeting, "Greetings from process %d of %d!", my_rank, comm_sz);
		MPI_Send(greeting, strlen(greeting) + 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
	}
	else
	{
		printf("Greetings from process %d of %d!\n", my_rank, comm_sz);
		for (int q = 1; q < comm_sz; q++)
		{
			MPI_Recv(greeting, MAX_STRING, MPI_CHAR, q, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
			printf("%s\n", greeting);
		}
	}

	MPI_Finalize();
	return 0;
}

参考

win10环境下vs2013+mpich2并行环境搭建_vs2013 mpich-CSDN博客

MPI并行环境配置（Windows 10＋VSIDE Community 2019）_amd mpi并行-CSDN博客

windows下安装mpich2_如何安装spmd。exe-CSDN博客

Index of /static/downloads/1.4

创作不易，小小的支持一下吧！

展开全文 >>

Electron qt开发教程

2024-06-08

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/139549350

模块安装打包

npm install -g electron-forge
electron-forge init my-project –template=vue
npm start //进入目录启动
//打包成一个目录到out目录下，注意这种打包一般用于调试，并不是用于分发
npm run package
//打出真正的分发包，放在out\make目录下
npm run make

npx @electron-forge/cli@latest import
npx create-electron-app my-app

npm install mousetrap //快捷键绑定库

npm install worker_threads //工作线程模块
npm install worker-loader //
npm init //C++项目目录下初始化项目
npm install –global –production windows-build-tools

electron 将pc端（vue）页面打包为桌面端应用-CSDN博客

快速体验

npm install -g electron-prebuilt
git clone https://github.com/electron/electron-quick-start
cd electron-quick-start
npm install && npm start

cnpm install electron-packager -g
“scripts”: {“package”:”electron-packager . HelloWorld –platform=win32 –arch=x64 –icon=computer.ico –out=./out –asar –app-version=0.0.1 –overwrite –ignore=node_modules”
}
npm run package

GitHub - electron/electron-api-demos: Explore the Electron APIs

@python “%~dp0gyp_main.py” %*

JS调用C++

#include <node.h>
#include <v8.h>

using namespace v8;

// 传入了两个参数，args[0] 字符串，args[1] 回调函数
void hello(const FunctionCallbackInfo<Value>& args) {
  // 使用 HandleScope 来管理生命周期
  Isolate* isolate = Isolate::GetCurrent();
  HandleScope scope(isolate);

  // 判断参数格式和格式
  if (args.Length() < 2 || !args[0]->IsString()) {
    isolate->ThrowException(Exception::TypeError(
      String::NewFromUtf8(isolate, "Wrong arguments")));
    return;
  }

  // callback, 使用Cast方法来转换
  Local<Function> callback = Local<Function>::Cast(args[1]);
  Local<Value> argv[1] = {
    // 拼接String
    String::Concat(Local<String>::Cast(args[0]), String::NewFromUtf8(isolate, " world"))
  };
  // 调用回调, 参数: 当前上下文，参数个数，参数列表
  callback->Call(isolate->GetCurrentContext()->Global(), 1, argv);
}

// 相当于在 exports 对象中添加 { hello: hello }
void init(Local<Object> exports) {
  NODE_SET_METHOD(exports, "hello", hello);
}

// 将 export 对象暴露出去
// 原型 `NODE_MODULE(module_name, Initialize)`
NODE_MODULE(test, init);

//方法暴露
void Method(const FunctionCallbackInfo<Value>& args) {
  Isolate* isolate = args.GetIsolate();
  args.GetReturnValue().Set(String::NewFromUtf8(
      isolate, "world").ToLocalChecked());
}

void Initialize(Local<Object> exports) {
  NODE_SET_METHOD(exports, "hello", Method);
}

NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
extern "C" NODE_MODULE_EXPORT void
NODE_MODULE_INITIALIZER(Local<Object> exports,
                        Local<Value> module,
                        Local<Context> context) {
  /* Perform addon initialization steps here. */
}


int main(int argc, char* argv[]) {
  // Create a stack-allocated handle scope. 
  HandleScope handle_scope;
  // Create a new context. 
  Handle<Context> context = Context::New();
  // Enter the created context for compiling and 
  // running the hello world script.
  Context::Scope context_scope(context);
  // Create a string containing the JavaScript source code. 
  Handle<String> source = String::New("'Hello' + ', World!'");
  // Compile the source code. 
  Handle<Script> script = Script::Compile(source);
  // Run the script to get the result. 
  Handle<Value> result = script->Run();
  // Convert the result to an ASCII string and print it. 
  String::AsciiValue ascii(result);
  printf("%s\n", *ascii);
  return 0;
}

//create accessor for string username
global->SetAccessor(v8::String::New("user"),userGetter,userSetter); 
//associates print on script to the Print function
global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print)); 

//注册类对象
Handle<FunctionTemplate> point_templ = FunctionTemplate::New();
point_templ->SetClassName(String::New("Point"));
Handle<ObjectTemplate> point_proto = point_templ->PrototypeTemplate();
point_proto->Set("method_a", FunctionTemplate::New(PointMethod_A));
point_proto->Set("method_b", FunctionTemplate::New(PointMethod_B));
//设置指针个数
Handle<ObjectTemplate> point_inst = point_templ->InstanceTemplate();
point_inst->SetInternalFieldCount(1);
//创建实例
Handle<Function> point_ctor = point_templ->GetFunction();
Local<Object> obj = point_ctor->NewInstance();
obj->SetInternalField(0, External::New(p));
//获取类指针处理
     Handle<Value> PointMethod_A(const Arguments& args)

2.                {

3.                    Local<Object> self = args.Holder();

4.                    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));

5.                    void* ptr = wrap->Value();

6.                    static_cast<Point*>(ptr)->Function_A();

7.                    return Integer::New(static_cast<Point*>(ptr)->x_);

8.                }

//向MakeWeak注册的callback.  
void CloudAppWeakReferenceCallback(Persistent<Value> object  
                                                , void * param) {  
    if (CloudApp* cloudapp = static_cast<CloudApp*>(param)) {  
        delete cloudapp;  
    }  
}  
  
//将C++指针通过External保存为Persistent对象，避免的指针被析构  
Handle<External> MakeWeakCloudApp(void* parameter) {  
    Persistent<External> persistentCloudApp =   
        Persistent<External>::New(External::New(parameter));  
          
//MakeWeak非常重要，当JS世界new一个CloudApp对象之后  
//C++也必须new一个对应的指针。  
//JS对象析构之后必须想办法去析构C++的指针，可以通过MakeWeak来实现，  
//MakeWeak的主要目的是为了检测Persistent Handle除了当前Persistent   
//的唯一引用外，没有其他的引用，就可以析构这个Persistent Handle了，  
//同时调用MakeWeak的callback。这是我们可以再这个callback中delete   
//C++指针  
    persistentCloudApp.MakeWeak(parameter, CloudAppWeakReferenceCallback);  
  
    return persistentCloudApp;  
}  

void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {  
  bool first = true;  
  for (int i = 0; i < args.Length(); i++) {  
    v8::HandleScope handle_scope(args.GetIsolate());  
    if (first) {  
      first = false;  
    } else {  
      printf(" ");  
    }  
    v8::String::Utf8Value str(args[i]);  
    const char* cstr = ToCString(str);  
    printf("%s", cstr);  
    const char* s_result = "print call succeed\n";  
    v8::Local<v8::String>  v_result = v8::String::NewFromUtf8(args.GetIsolate(), s_result,  
        v8::NewStringType::kNormal).ToLocalChecked();  
    args.GetReturnValue().Set(v_result);  
  }  
  printf("\n");  
  fflush(stdout);  
}  
v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);  
  // Bind the global 'print' function to the C++ Print callback.  
  global->Set(  
      v8::String::NewFromUtf8(isolate, "print", v8::NewStringType::kNormal)  
          .ToLocalChecked(),  
      v8::FunctionTemplate::New(isolate, Print));  
Local<Context> context = v8::Context::New(isolate, NULL, global);

Isolate *isolate = args.GetIsolate();
Local<Object> opts = args[0]->ToObject();
Local<Number> mode = opts->Get(String::NewFromUtf8(isolate, "mode"))->ToNumber(isolate);
static void DeleteInstance(void* data) {
  // 将 `data` 转换为该类的实例并删除它。
}
node::AddEnvironmentCleanupHook(DeleteInstance) //在销毁环境之后被删除
JS调用C++函数，就是通过FunctionTemplate和ObjectTemplate进行扩展的。
V8的External就是专门用来封装（Wrap）和解封(UnWrap)C++指针的

V8_EXPORT
V8_INLINE
v8::Handle<
v8::Local<
const v8::Arguments
const v8::FunctionCallbackInfov8::Value& 不定参数
Local tpl = FunctionTemplate::New(isolate);
G
String::NewFromUtf8Literal(isolate, “isNull”)
String::Cast
isolate->GetCurrentContext()
NODE_SET_PROTOTYPE_METHOD(tpl, “x”, X);

https://github.com/alibaba/jsni.git

nodeqt

const qt = require("./lib/qt");
const app = new qt.QApplication();
const window = new qt.QMainWindow();
const box = new qt.QWidget();
box.setStyleSheet("background-color:red;");
box.resize(300, 300);
box.move(300, 300);
box.setParent(window);
window.resizeEvent((width, height) => {
  console.log("Resized1", width, height);
  console.log(width, height);
});
window.closeEvent(() => {
  console.log("Closing");
});
box.resizeEvent((width, height) => {
  console.log("Resized2", width, height);
});
box.mousePressEvent(() => console.log("CLICKED!"));
box.mouseReleaseEvent(() => console.log("UNCLICKED!"));
box.setMouseTracking(true);
box.mouseMoveEvent((x, y) => console.log(`MOUSE MOVED! x: ${x} y: ${y}`));
box.enterEvent(() => console.log("MOUSE ENTERED!"));
box.leaveEvent(() => console.log("MOUSE LEFT!"));
const label = new qt.QLabel(box);
console.log("Size hint", label.sizeHint());
console.log("Height", label.height());
label.setText('<span style="">dsawewwww<span style="">Hello2</span></span>');
label.adjustSize();
const label2 = new qt.QLabel(window);
const pix = new qt.QPixmap();
pix.load("/home/kusti8/Pictures/test_small.jpg");
pix.scaled(300, 300, qt.AspectRatioMode.IgnoreAspectRatio);
label2.setPixmap(pix);
label2.adjustSize();
label2.setStyleSheet("background-color: red;");
label2.move(300, 600);
label2.setScaledContents(false);
label2.setAlignment(qt.Alignment.AlignCenter);
label2.show();
const lineedit = new qt.QLineEdit(window);
lineedit.move(100, 100);
lineedit.textChangedEvent(text => console.log("text changed", text));
lineedit.show();
const combobox = new qt.QComboBox(window);
combobox.currentTextChangedEvent(text => console.log("New combo", text));
combobox.setEditable(true);
combobox.addItem("Test1");
combobox.addItem("Test2");
combobox.addItem("Test3");
box.show();
box.clear();
console.log("set parent");
window.show();
console.log("set parent");
app.aboutToQuitEvent(() => console.log("Quitting"));
console.log("Height", label.height());
console.log(qt.desktopSize());
app.exec();

GitHub - arturadib/node-qt: C++ Qt bindings for Node.js

mirrors_CoderPuppy/node-qt

GitHub - anak10thn/node-qt5

GitHub - NickCis/nodeQt: Qt binding for Node

GitHub - a7ul/mdview-nodegui: A Markdown editor in NodeGui

GitHub - kusti8/node-qt-napi: Node.js bindinds for Qt5, using NAPI

GitHub - nodegui/qode: DEPRECATED: Please see https://github.com/nodegui/qodejs instead

GitHub - svalaskevicius/qtjs-generator: Qt API bindings generator for Node.js

C++ 插件 | Node.js v22 文档

GitHub - nodegui/nodegui-starter: A starter repo for NodeGui projects

GitHub - anak10thn/qhttpserver: HTTP server implementation for Qt based on node.js’ http parser

GitHub - anak10thn/chrome-app-samples: Chrome Apps

GitHub - magne4000/node-qtdatastream: Nodejs lib which can read/write Qt formatted Datastreams

GitHub - fwestrom/qtort-microservices: A simple micro-services framework for Node.js.

GitHub - ivan770/PiQture: Screenshot tool based on Electron

GitHub - miskun/qtc-sdk-node: Qt Cloud Services SDK for Node.js

v8: include/v8.h File Reference

nodegyp

node-gyp -j 8 configure
node-gyp -j 8 build
“install”: “node-gyp -j 8 rebuild –arch=ia32”
“install”: “node-gyp -j 8 rebuild –arch=x86”

https://github.com/kusti8/node-qt-napi/releases/download/0.0.4/qt-v0.0.4-4-win32-x64.tar.gz

工程搭建方式

gyp文件样例

TortoiseGit bash使用

set PRJ_PATH=E:\workspace\test\Web-Dev-For-Beginners\nodeqt
TortoiseGitProc.exe /command:commit /path:"%PRJ_PATH%\nodegyp" /logmsgfile:"%PRJ_PATH%\refModify.txt"  /bugid:1 /closeonend:2%
TortoiseGitProc.exe /command:pull /path:"%PRJ_PATH%\nodegyp" /closeonend:2
TortoiseGitProc.exe /command:push /path:"%PRJ_PATH%\nodegyp" /closeonend:2
pause

git bash使用

git config --global user.name "your-name"
git config --global user.email "your-email"

git init  	@ Initialize a git repositor
git status		@Check status
git add .
git add [file or folder name]
git reset 		//将文件还原到上一个commit
git reset [file or folder name]   //特定文件还原到上一个commit
git commit -m "first commit"
git remote add origin https://github.com/username/repository_name.git  //添加远程仓库地址
git push -u origin main   //This sends your commits in your "main" branch to GitHub
git branch [branch-name]  		//Create a branch
git checkout [branch-name]		//Switch to working branch

git checkout main
git pull			//Combine your work with the main branch
git checkout [branch_name]
git merge main		//conflicts combine the changes happens in your working branch.
git push --set-upstream origin [branch-name]  	//Send your work to GitHub
git branch -d [branch-name]   	//clean up both your local branch
git pull

参考

[GitHub - electron/electron-api-demos: Explore the Electron APIsExplore the Electron APIs. Contribute to electron/electron-api-demos development by creating an account on GitHub.

icon-default.png?t=N7T8

https://github.com/electron/electron-api-demos](https://github.com/electron/electron-api-demos “GitHub - electron/electron-api-demos: Explore the Electron APIs”)[Quick Start | ElectronThis guide will step you through the process of creating a barebones Hello World app in Electron, similar to electron/electron-quick-start.

icon-default.png?t=N7T8

https://electronjs.org/docs/tutorial/quick-start](https://electronjs.org/docs/tutorial/quick-start “Quick Start | Electron”)[https://github.com/electron/electron-quick-start

icon-default.png?t=N7T8

https://github.com/electron/electron-quick-start](https://github.com/electron/electron-quick-start “https://github.com/electron/electron-quick-start“) GitHub - qtoolkit/qtk: QTK 是一套基于HTML5 Canvas实现的, 专注于桌面/移动应用程序开发的框架。

https://github.com/sindresorhus/awesome-electron

Introduction | Electron

Electron

node与Electron版本对应

GitHub - atom/atom: :atom: The hackable text editor

GitHub - nodejs/node-addon-api: Module for using Node-API from C++

GitHub - glencornell/TinyEventLib: A tiny clean room implementation of the event processing loop in Qt